home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / lib / gedit-2 / plugins / snippets / Snippet.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-04-20  |  10.2 KB  |  308 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import os
  5. import gio
  6. from Placeholder import *
  7. from Parser import Parser, Token
  8. from Helper import *
  9.  
  10. class EvalUtilities:
  11.     
  12.     def __init__(self, view = None):
  13.         self.view = view
  14.         self._init_namespace()
  15.  
  16.     
  17.     def _init_namespace(self):
  18.         self.namespace = {
  19.             '__builtins__': __builtins__,
  20.             'align': self.util_align,
  21.             'readfile': self.util_readfile,
  22.             'filesize': self.util_filesize }
  23.  
  24.     
  25.     def _real_len(self, s, tablen = 0):
  26.         if tablen == 0:
  27.             tablen = self.view.get_tab_width()
  28.         
  29.         return len(s.expandtabs(tablen))
  30.  
  31.     
  32.     def _filename_to_uri(self, filename):
  33.         gfile = gio.File(filename)
  34.         return gfile.get_uri()
  35.  
  36.     
  37.     def util_readfile(self, filename):
  38.         stream = gio.File(filename).read()
  39.         if not stream:
  40.             return ''
  41.         res = stream.read()
  42.         stream.close()
  43.         return res
  44.  
  45.     
  46.     def util_filesize(self, filename):
  47.         gfile = gio.File(filename)
  48.         info = gfile.query_info(gio.FILE_ATTRIBUTE_STANDARD_SIZE)
  49.         if not info:
  50.             return 0
  51.         return info.get_size()
  52.  
  53.     
  54.     def util_align(self, items):
  55.         maxlen = []
  56.         tablen = self.view.get_tab_width()
  57.         for row in range(0, len(items)):
  58.             for col in range(0, len(items[row]) - 1):
  59.                 if row == 0:
  60.                     maxlen.append(0)
  61.                 
  62.                 items[row][col] += '\t'
  63.                 rl = self._real_len(items[row][col], tablen)
  64.                 if rl > maxlen[col]:
  65.                     maxlen[col] = rl
  66.                     continue
  67.             
  68.         
  69.         result = ''
  70.         for row in range(0, len(items)):
  71.             for col in range(0, len(items[row]) - 1):
  72.                 item = items[row][col]
  73.                 result += item + '\t' * ((maxlen[col] - self._real_len(item, tablen)) / tablen)
  74.             
  75.             result += items[row][len(items[row]) - 1]
  76.             if row != len(items) - 1:
  77.                 result += '\n'
  78.                 continue
  79.         
  80.         return result
  81.  
  82.  
  83.  
  84. class Snippet:
  85.     
  86.     def __init__(self, data):
  87.         self.data = data
  88.  
  89.     
  90.     def __getitem__(self, prop):
  91.         return self.data[prop]
  92.  
  93.     
  94.     def __setitem__(self, prop, value):
  95.         self.data[prop] = value
  96.  
  97.     
  98.     def accelerator_display(self):
  99.         accel = self['accelerator']
  100.         if accel:
  101.             (keyval, mod) = gtk.accelerator_parse(accel)
  102.             accel = gtk.accelerator_get_label(keyval, mod)
  103.         
  104.         if not accel:
  105.             pass
  106.         return ''
  107.  
  108.     
  109.     def display(self):
  110.         nm = markup_escape(self['description'])
  111.         tag = self['tag']
  112.         accel = self.accelerator_display()
  113.         detail = []
  114.         if tag and tag != '':
  115.             detail.append(tag)
  116.         
  117.         if accel and accel != '':
  118.             detail.append(accel)
  119.         
  120.         if not detail:
  121.             return nm
  122.         return nm + ' (<b>' + markup_escape(str.join(', ', detail)) + '</b>)'
  123.  
  124.     
  125.     def _add_placeholder(self, placeholder):
  126.         if placeholder.tabstop in self.placeholders:
  127.             if placeholder.tabstop == -1:
  128.                 self.placeholders[-1].append(placeholder)
  129.                 self.plugin_data.ordered_placeholders.append(placeholder)
  130.             
  131.         elif placeholder.tabstop == -1:
  132.             self.placeholders[-1] = [
  133.                 placeholder]
  134.             self.plugin_data.ordered_placeholders.append(placeholder)
  135.         else:
  136.             self.placeholders[placeholder.tabstop] = placeholder
  137.             self.plugin_data.ordered_placeholders.append(placeholder)
  138.  
  139.     
  140.     def _insert_text(self, text):
  141.         indented = unicode.join('\n' + unicode(self._indent), spaces_instead_of_tabs(self._view, text).split('\n'))
  142.         self._view.get_buffer().insert(self._insert_iter(), indented)
  143.  
  144.     
  145.     def _insert_iter(self):
  146.         return self._view.get_buffer().get_iter_at_mark(self._insert_mark)
  147.  
  148.     
  149.     def _create_environment(self, data):
  150.         if not data in os.environ or os.environ[data]:
  151.             pass
  152.         val = ''
  153.         all_indent = compute_indentation(self._view, self._insert_iter())
  154.         indent = all_indent[len(self._indent):]
  155.         return unicode.join('\n' + unicode(indent), val.split('\n'))
  156.  
  157.     
  158.     def _create_placeholder(self, data):
  159.         tabstop = data['tabstop']
  160.         begin = self._insert_iter()
  161.         if tabstop == 0:
  162.             return PlaceholderEnd(self._view, begin, data['default'])
  163.         if tabstop in self.placeholders:
  164.             return PlaceholderMirror(self._view, tabstop, begin)
  165.         return Placeholder(self._view, tabstop, data['default'], begin)
  166.  
  167.     
  168.     def _create_shell(self, data):
  169.         begin = self._insert_iter()
  170.         return PlaceholderShell(self._view, data['tabstop'], begin, data['contents'])
  171.  
  172.     
  173.     def _create_eval(self, data):
  174.         begin = self._insert_iter()
  175.         return PlaceholderEval(self._view, data['tabstop'], data['dependencies'], begin, data['contents'], self._utils.namespace)
  176.  
  177.     
  178.     def _create_regex(self, data):
  179.         begin = self._insert_iter()
  180.         return PlaceholderRegex(self._view, data['tabstop'], begin, data['input'], data['pattern'], data['substitution'], data['modifiers'])
  181.  
  182.     
  183.     def _create_text(self, data):
  184.         return data
  185.  
  186.     
  187.     def _invalid_placeholder(self, placeholder, remove):
  188.         buf = self._view.get_buffer()
  189.         if placeholder.default and remove:
  190.             buf.delete(placeholder.begin_iter(), placeholder.end_iter())
  191.         
  192.         placeholder.remove()
  193.         if placeholder.tabstop == -1:
  194.             index = self.placeholders[-1].index(placeholder)
  195.             del self.placeholders[-1][index]
  196.         else:
  197.             del self.placeholders[placeholder.tabstop]
  198.         self.plugin_data.ordered_placeholders.remove(placeholder)
  199.  
  200.     
  201.     def _parse(self, plugin_data):
  202.         self._view = plugin_data.view
  203.         self._indent = compute_indentation(self._view, self._view.get_buffer().get_iter_at_mark(self.begin_mark))
  204.         self._utils = EvalUtilities(self._view)
  205.         self.placeholders = { }
  206.         self._insert_mark = self.end_mark
  207.         self.plugin_data = plugin_data
  208.         parser = Parser(data = self['text'])
  209.         while True:
  210.             token = parser.token()
  211.             if not token:
  212.                 break
  213.             
  214.             
  215.             try:
  216.                 val = {
  217.                     'environment': self._create_environment,
  218.                     'placeholder': self._create_placeholder,
  219.                     'shell': self._create_shell,
  220.                     'eval': self._create_eval,
  221.                     'regex': self._create_regex,
  222.                     'text': self._create_text }[token.klass](token.data)
  223.             except:
  224.                 sys.stderr.write('Token class not supported: %s\n' % token.klass)
  225.                 continue
  226.  
  227.             if isinstance(val, basestring):
  228.                 self._insert_text(val)
  229.                 continue
  230.             self._add_placeholder(val)
  231.         if 0 not in self.placeholders:
  232.             self.placeholders[0] = PlaceholderEnd(self._view, self.end_iter(), None)
  233.             self.plugin_data.ordered_placeholders.append(self.placeholders[0])
  234.         
  235.         for tabstop in self.placeholders.copy():
  236.             if not tabstop == -1 or list(self.placeholders[-1]):
  237.                 pass
  238.             ph = [
  239.                 self.placeholders[tabstop]]
  240.             for placeholder in ph:
  241.                 placeholder.run_last(self.placeholders)
  242.                 if not (placeholder.ok) or placeholder.done:
  243.                     self._invalid_placeholder(placeholder, not (placeholder.ok))
  244.                     continue
  245.             
  246.         
  247.         if -1 not in self.placeholders:
  248.             self.placeholders[-1] = []
  249.         
  250.         for tabstop in self.placeholders.copy():
  251.             placeholder = self.placeholders[tabstop]
  252.             if tabstop != -1:
  253.                 if isinstance(placeholder, PlaceholderExpand) and placeholder.has_references:
  254.                     self.placeholders[-1].append(placeholder)
  255.                     del self.placeholders[tabstop]
  256.                 
  257.             placeholder.has_references
  258.         
  259.         self.plugin_data = None
  260.  
  261.     
  262.     def insert_into(self, plugin_data, insert):
  263.         buf = plugin_data.view.get_buffer()
  264.         last_index = 0
  265.         (current, next) = plugin_data.next_placeholder()
  266.         if current:
  267.             last_index = plugin_data.placeholders.index(current) + 1
  268.         elif next:
  269.             last_index = plugin_data.placeholders.index(next)
  270.         else:
  271.             last_index = 0
  272.         self.begin_mark = buf.create_mark(None, insert, True)
  273.         self.end_mark = buf.create_mark(None, insert, False)
  274.         self._parse(plugin_data)
  275.         k = self.placeholders.keys()
  276.         k.sort(reverse = True)
  277.         plugin_data.placeholders.insert(last_index, self.placeholders[0])
  278.         last_iter = self.placeholders[0].end_iter()
  279.         for tabstop in k:
  280.             if tabstop != -1 and tabstop != 0:
  281.                 placeholder = self.placeholders[tabstop]
  282.                 end_iter = placeholder.end_iter()
  283.                 if last_iter.compare(end_iter) < 0:
  284.                     last_iter = end_iter
  285.                 
  286.                 plugin_data.placeholders.insert(last_index, placeholder)
  287.                 continue
  288.         
  289.         buf.move_mark(self.end_mark, last_iter)
  290.         return self
  291.  
  292.     
  293.     def deactivate(self):
  294.         buf = self.begin_mark.get_buffer()
  295.         buf.delete_mark(self.begin_mark)
  296.         buf.delete_mark(self.end_mark)
  297.         self.placeholders = { }
  298.  
  299.     
  300.     def begin_iter(self):
  301.         return self.begin_mark.get_buffer().get_iter_at_mark(self.begin_mark)
  302.  
  303.     
  304.     def end_iter(self):
  305.         return self.end_mark.get_buffer().get_iter_at_mark(self.end_mark)
  306.  
  307.  
  308.